#include <iostream>  
#include <string>  
#include <stack>  
#include <sstream> 
#include <fstream> 
#include <cctype>  
#include <algorithm>  

using namespace std;  
int flag=0;
bool isOperator(char c) {  
    return (c == '+' || c == '-' || c == '*' || c == '/');  // 检查字符是否为运算符  
}  

int getPrecedence(char op) {  
    if (op == '+' || op == '-')  // 加法和减法的优先级为1  
        return 1;  
    if (op == '*' || op == '/')  // 乘法和除法的优先级为2  
        return 2;  
    return 0;  
}  

bool isNumber(const string& str) {  
    stringstream ss(str);  
    float num;  
    return ss >> num && ss.eof();  // 检查字符串是否为数字  
}  

string infixToPostfix(const string& expression) {  
    stack<char> operators;  // 运算符栈  

    stringstream postfix;  // 后缀表达式字符串流  
    for (char c : expression) {  
        if (isdigit(c) || c == '.') {  
            postfix << c;  // 如果字符是数字或小数点，则直接添加到后缀表达式中  
        } else if (c == '(') {  
            operators.push(c);  // 如果字符是左括号，则将其压入运算符栈  
        } else if (c == ')') {  
            while (!operators.empty() && operators.top() != '(') {  
                postfix << ' ' << operators.top();  // 将运算符栈中的运算符添加到后缀表达式中  
                operators.pop();  
            }  
            if (!operators.empty() && operators.top() == '(') {  
                operators.pop();  // 弹出左括号  
            } else {  
                return "Error.";  // 括号不匹配，返回错误  
            }  
        } else if (isOperator(c)) {  
            postfix << ' ';  
            while (!operators.empty() && operators.top() != '(' &&  
                   getPrecedence(operators.top()) >= getPrecedence(c)) {  
                postfix << operators.top() << ' ';  // 将优先级较高的运算符添加到后缀表达式中  
                operators.pop();  
            }  
            operators.push(c);  // 将当前运算符压入运算符栈  
        }  
    }  
    while (!operators.empty()) {  
        if (operators.top() == '(') {  
            return "Error.";  // 括号不匹配，返回错误  
        }  
        postfix << ' ' << operators.top();  // 将剩余的运算符添加到后缀表达式中  
        operators.pop();  
    }  
    return postfix.str();  // 返回后缀表达式字符串  
}  

float evaluatePostfix(const string& postfix) {  
    stack<float> operands;  // 操作数栈  

    stringstream ss(postfix);  
    string token;  
    while (ss >> token) {  
        if (isNumber(token)) {  
            operands.push(stof(token));  // 如果字符串是数字，则将其转换为浮点数并压入操作数栈  
        } else if (isOperator(token[0])) {  
            if (operands.size() < 2) { 
                flag=1; 
                return 0;  // 表达式无效，返回0  
            }  
            float operand2 = operands.top();  // 弹出操作数栈顶的两个操作数  
            operands.pop();  
            float operand1 = operands.top();  
            operands.pop();  
            float result;  
            switch (token[0]) {  
                case '+':  
                    result = operand1 + operand2;  // 执行相应的运算  
                    break;  
                case '-':  
                    result = operand1 - operand2;  
                    break;  
                case '*':  
                    result = operand1 * operand2;  
                    break;  
                case '/':  
                    result = operand1 / operand2;  
                    break;  
            }  
            operands.push(result);  // 将计算结果压入操作数栈  
        }  
    }  
    if (operands.size() == 1) {  
        return operands.top();  // 返回最终结果  
    } else {  
        flag=1;
        return 0;  // 表达式无效，返回0  
    }  
}  

float evaluateExpression(const string& expression) {  
    string postfix = infixToPostfix(expression);  // 将中缀表达式转换为后缀表达式  
    if (postfix == "Error.") {  
        flag=1;
        return 0;  // 表达式无效，返回0  
    }  
    return evaluatePostfix(postfix);  // 计算后缀表达式的结果  

}  

int main() {  
    ifstream inputFile("input.txt"); // 打开 input.txt 文件  
    if (!inputFile) {  
        cout << "无法打开文件 input.txt" << endl;  
        return 1;  
    }  

    string input;  
    while (getline(inputFile, input)) { 
        flag=0;
        // 移除非数字、运算符和空格的字符  
        input.erase(remove_if(input.begin(), input.end(), [](char c) {  
            return !(isdigit(c) || c == '.' || isOperator(c) || c == '(' || c == ')' || c == ' ');  
        }), input.end());  
        float result = evaluateExpression(input); // 计算表达式的结果  
        if (result == 0&&flag==1) {  
            cout << "Error" << endl; 
        } else {  
            cout << "result: " << result << endl;  
        }  
    }  
    inputFile.close(); // 关闭文件  
    return 0;  
}
